JavaScript Alerts are browser-level dialog boxes generated by JavaScript that require a specific user action before the browser can continue interacting with the web page. In Selenium automation, JavaScript alerts cannot be handled like normal HTML WebElements because they are outside the regular DOM. Selenium provides the Alert interface through which testers can switch to, read, accept, dismiss, and enter text into JavaScript alert dialogs.
Handling alerts is an important part of Selenium WebDriver automation because real-world web applications may display confirmation messages, warnings, authentication prompts, delete confirmations, session notifications, and other JavaScript-based dialogs during test execution.
For structured Selenium learning and practical automation training, visit Selenium Training Course | Selenium Course Demo.
A JavaScript alert is a browser dialog displayed by JavaScript to communicate information to the user or request an action. These dialogs temporarily interrupt normal interaction with the web page until the user responds.
For example:
alert("Record saved successfully");When this JavaScript executes, the browser displays a dialog containing the message and an OK button.
Automated test scripts frequently encounter JavaScript dialogs while testing web applications. If Selenium encounters an unexpected alert and the script does not handle it correctly, subsequent browser interactions may fail.
A JavaScript alert is created by JavaScript running inside the web application.
Basic flow:
Web Page
↓
JavaScript Executes
↓
Browser Dialog Appears
↓
Selenium Detects Alert
↓
driver.switchTo().alert()
↓
Accept / Dismiss / Get Text / Send Keys
↓
Browser Continues
The three primary JavaScript dialog types commonly encountered in Selenium are:
| Dialog Type | JavaScript Method | Typical Buttons | Purpose |
|---|---|---|---|
| Alert | alert() | OK | Displays information or warning |
| Confirmation | confirm() | OK / Cancel | Requests user confirmation |
| Prompt | prompt() | OK / Cancel | Requests text input |
The alert() method displays a simple message and normally provides an OK button.
<script>
alert("Welcome to the application");
</script>
In Selenium, the alert can be accepted using:
Alert alert = driver.switchTo().alert();
alert.accept();
The confirm() method displays a confirmation dialog. It normally provides OK and Cancel buttons.
<script>
confirm("Are you sure you want to delete this record?");
</script>
Clicking OK is equivalent to accepting the alert:
Alert alert = driver.switchTo().alert();
alert.accept();
Clicking Cancel is equivalent to dismissing it:
Alert alert = driver.switchTo().alert();
alert.dismiss();
The prompt() method displays a dialog that allows the user to enter text.
<script>
prompt("Enter your username");
</script>
Selenium can enter text into a prompt using sendKeys().
Alert alert = driver.switchTo().alert();
alert.sendKeys("Manish");
alert.accept();
Selenium provides the Alert interface for interacting with JavaScript dialogs.
The most commonly used methods are:
| Method | Purpose |
|---|---|
accept() | Clicks the OK button |
dismiss() | Clicks the Cancel button |
getText() | Retrieves alert message text |
sendKeys() | Enters text into a prompt |
Before interacting with a JavaScript alert, Selenium must switch the driver's focus to the alert.
Alert alert = driver.switchTo().alert();Alternatively, the statement can be written directly:
driver.switchTo().alert().accept();The accept() method clicks the OK button of the JavaScript dialog.
driver.switchTo().alert().accept();Typical use cases include:
The dismiss() method clicks the Cancel button when the dialog provides one.
driver.switchTo().alert().dismiss();This is commonly used when testing negative or cancellation scenarios.
The getText() method retrieves the text displayed inside the alert.
Alert alert = driver.switchTo().alert();
String message = alert.getText();
System.out.println(message);
This is useful when the expected alert message is part of the test requirement.
Alert text can be verified using Java assertions.
Alert alert = driver.switchTo().alert();
String actualMessage = alert.getText();
String expectedMessage = "Record deleted successfully";
Assert.assertEquals(actualMessage, expectedMessage);
alert.accept();
A prompt allows the user to enter information. Selenium uses the sendKeys() method to provide that input.
Alert alert = driver.switchTo().alert();
alert.sendKeys("Test User");
alert.accept();
import java.time.Duration;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class AlertExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
driver.manage().window().maximize();
driver.get("https://example.com");
driver.findElement(By.id("alertButton")).click();
Alert alert = driver.switchTo().alert();
System.out.println("Alert Message: " + alert.getText());
alert.accept();
driver.quit();
}
}
| Operation | Selenium Code |
|---|---|
| Switch to alert | driver.switchTo().alert() |
| Accept | alert.accept() |
| Dismiss | alert.dismiss() |
| Read text | alert.getText() |
| Enter prompt text | alert.sendKeys("text") |
One of the most important concepts in Selenium is understanding the difference between a JavaScript alert and an HTML modal dialog.
| JavaScript Alert | HTML Modal |
|---|---|
| Browser-managed dialog | Part of the web page DOM |
| Handled using Alert interface | Handled using WebElement locators |
Use switchTo().alert() | Use findElement() |
| Not normally inspected as a normal DOM element | Can usually be inspected in DevTools |
| Can block page interaction | Usually behaves like page content |
Not every popup displayed by a website is a JavaScript alert.
| Popup Type | Typical Selenium Handling |
|---|---|
| JavaScript Alert | driver.switchTo().alert() |
| HTML Modal | WebElement locators |
| New Browser Window | Window handles |
| New Browser Tab | Window handles |
| Authentication Dialog | Depends on browser/application implementation |
Selenium normally interacts with elements in the current browsing context. A JavaScript alert is a separate browser-level dialog. Therefore, Selenium must change its current interaction target to the alert.
driver.switchTo().alert();After switching, Selenium can perform alert-specific operations.
If an alert is open and the test tries to interact with the underlying page, Selenium may fail because the alert is blocking normal browser interaction.
For example:
driver.findElement(By.id("submit")).click();
driver.switchTo().alert().accept();
The sequence is incorrect when the alert appears before the submit interaction can continue. The alert should be handled at the point where it appears.
Perform Action
↓
Alert Appears
↓
Switch to Alert
↓
Read Alert Text if Required
↓
Accept or Dismiss
↓
Continue Test
Alerts may not appear immediately after an action. In such cases, an explicit wait can wait for the alert to become available.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
driver.findElement(By.id("deleteButton")).click();
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
System.out.println(alert.getText());
alert.accept();
alertIsPresent() is useful when the alert appears asynchronously.
A fixed delay can technically be used, but it is generally less desirable for reliable automation.
Thread.sleep(3000);
driver.switchTo().alert().accept();
The problem is that the alert may appear before three seconds or after three seconds. An explicit wait is usually more appropriate for dynamic timing.
If Selenium tries to switch to an alert when no alert is currently present, an exception can occur.
driver.switchTo().alert();When no alert exists, Selenium may throw NoAlertPresentException.
The exception can be handled when the alert is optional or when the test needs controlled recovery.
try {
Alert alert = driver.switchTo().alert();
System.out.println(alert.getText());
alert.accept();
} catch (NoAlertPresentException e) {
System.out.println("No alert was displayed.");
}
However, exceptions should not simply be swallowed. If an alert was required by the test, the test should normally fail or report the missing alert rather than silently continuing.
Sometimes an application displays an alert only under certain conditions. In such situations, the test can wait briefly for an alert and then continue if it does not appear.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
try {
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
System.out.println(alert.getText());
alert.accept();
} catch (TimeoutException e) {
System.out.println("Optional alert did not appear.");
}
Validation should compare the actual message with the expected business requirement.
Alert alert = driver.switchTo().alert();
String actual = alert.getText();
Assert.assertEquals(
actual,
"Are you sure you want to delete this record?"
);
alert.dismiss();
Confirmation dialogs are commonly used for destructive operations such as deleting a record.
driver.findElement(By.id("deleteButton")).click();
Alert alert = driver.switchTo().alert();
Assert.assertEquals(
alert.getText(),
"Are you sure you want to delete this record?"
);
alert.accept();
Negative testing should also verify what happens when the user chooses Cancel.
driver.findElement(By.id("deleteButton")).click();
Alert alert = driver.switchTo().alert();
alert.dismiss();
The test can then verify that the record was not deleted.
A prompt should be tested by entering valid, invalid, empty, boundary, and special-character values when those scenarios are part of the application's requirements.
driver.findElement(By.id("promptButton")).click();
Alert alert = driver.switchTo().alert();
alert.sendKeys("Automation Tester");
alert.accept();
driver.findElement(By.id("promptButton")).click();
Alert alert = driver.switchTo().alert();
String message = alert.getText();
System.out.println("Prompt Message: " + message);
alert.sendKeys("Selenium User");
alert.accept();
String result = driver.findElement(By.id("result")).getText();
Assert.assertEquals(result, "Selenium User");
A common Selenium scenario is clicking a button that triggers a JavaScript alert.
driver.findElement(By.id("showAlert")).click();
Alert alert = driver.switchTo().alert();
System.out.println(alert.getText());
alert.accept();
driver.findElement(By.id("username")).sendKeys("testuser");
driver.findElement(By.id("password")).sendKeys("password123");
driver.findElement(By.id("login")).click();
Alert alert = driver.switchTo().alert();
String message = alert.getText();
System.out.println("Alert: " + message);
alert.accept();
import org.testng.Assert;
import org.testng.annotations.Test;
@Test
public void verifyAlert() {
driver.findElement(By.id("alertButton")).click();
Alert alert = driver.switchTo().alert();
String actualMessage = alert.getText();
Assert.assertEquals(
actualMessage,
"Operation completed successfully"
);
alert.accept();
}
Alert-related operations can be encapsulated inside page classes when the alert belongs logically to a page action.
public void deleteRecord() {
deleteButton.click();
}
public String getAlertMessage() {
return driver.switchTo().alert().getText();
}
public void acceptAlert() {
driver.switchTo().alert().accept();
}
public void dismissAlert() {
driver.switchTo().alert().dismiss();
}
A reusable alert utility can reduce duplicate code across automation tests.
public class AlertHelper {
private WebDriver driver;
public AlertHelper(WebDriver driver) {
this.driver = driver;
}
public void acceptAlert() {
driver.switchTo().alert().accept();
}
public void dismissAlert() {
driver.switchTo().alert().dismiss();
}
public String getAlertText() {
return driver.switchTo().alert().getText();
}
public void enterText(String text) {
driver.switchTo().alert().sendKeys(text);
}
}
AlertHelper alertHelper = new AlertHelper(driver);
driver.findElement(By.id("deleteButton")).click();
String message = alertHelper.getAlertText();
System.out.println(message);
alertHelper.acceptAlert();
accept() for OK.dismiss() for Cancel.sendKeys() for prompt input.Thread.sleep().Incorrect approach:
WebElement alert = driver.findElement(By.id("alert"));A native JavaScript alert is not normally handled as a DOM WebElement. The correct approach is:
Alert alert = driver.switchTo().alert();The WebDriver object does not provide the accept() method directly.
Correct:
driver.switchTo().alert().accept();The alert text should be retrieved from the Alert object.
Alert alert = driver.switchTo().alert();
String message = alert.getText();
For a JavaScript prompt, the text should be sent to the alert object.
Alert alert = driver.switchTo().alert();
alert.sendKeys("Test Data");
alert.accept();
A simple alert() normally has only an OK button. The normal operation is to accept it.
driver.switchTo().alert().accept();If the alert is created asynchronously, immediately calling switchTo().alert() may execute before the alert exists.
Use:
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
alert.accept();
Alert handling and synchronization are closely related. A test must synchronize with the point at which the browser dialog becomes available.
Click Button
↓
Application Processing
↓
JavaScript Executes
↓
Alert Appears
↓
Wait for Alert
↓
Switch to Alert
↓
Validate / Accept / Dismiss
↓
Continue Test
Modern applications may trigger JavaScript dialogs after AJAX requests, asynchronous operations, validation checks, or API responses. Therefore, alert timing should not always be assumed to be immediate.
driver.findElement(By.id("processButton")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
String message = alert.getText();
System.out.println(message);
alert.accept();
After accepting or dismissing an alert, Selenium can normally continue interacting with the page.
Alert alert = driver.switchTo().alert();
alert.accept();
driver.findElement(By.id("nextButton")).click();
If multiple alerts appear sequentially, each alert must be handled before continuing to the next application action.
Alert alert = driver.switchTo().alert();
System.out.println(alert.getText());
alert.accept();
Alert secondAlert = driver.switchTo().alert();
System.out.println(secondAlert.getText());
secondAlert.accept();
In dynamic applications, explicit waits can be added before each alert when necessary.
public void acceptAlert(WebDriver driver) {
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
alert.accept();
}
public String getAlertText(WebDriver driver) {
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
return alert.getText();
}
public void enterAlertText(WebDriver driver, String text) {
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
alert.sendKeys(text);
alert.accept();
}
Some applications may display an alert when invalid login credentials are submitted.
driver.findElement(By.id("username")).sendKeys("wrongUser");
driver.findElement(By.id("password")).sendKeys("wrongPassword");
driver.findElement(By.id("loginButton")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
String message = alert.getText();
Assert.assertEquals(message, "Invalid username or password");
alert.accept();
driver.findElement(By.id("deleteButton")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
Assert.assertEquals(
alert.getText(),
"Are you sure you want to delete?"
);
alert.accept();
Assert.assertTrue(
driver.findElement(By.id("successMessage")).isDisplayed()
);
A complete confirmation-dialog test should consider both possible user decisions.
| Scenario | Action | Expected Result |
|---|---|---|
| Confirm deletion | Accept | Record is deleted |
| Cancel deletion | Dismiss | Record remains |
An alert-related failure can sometimes look like a synchronization problem. For example, the test may immediately call switchTo().alert() before the application has created the dialog.
Correct approach:
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
alert.accept();
try {
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
System.out.println("Alert: " + alert.getText());
alert.accept();
} catch (TimeoutException e) {
System.out.println("Expected alert did not appear.");
}
A JavaScript alert temporarily takes control of browser interaction. Selenium must interact with the alert before normal page interaction can continue.
Page Context
↓
JavaScript Alert
↓
Alert Context
↓
Accept / Dismiss / Input
↓
Page Context
In a framework, alert handling should ideally be centralized through utility methods instead of duplicating low-level alert code in every test.
Test Case
↓
Page Object
↓
Alert Utility
↓
WebDriver Alert API
↓
Browser Dialog
| Utility Method | Purpose |
|---|---|
acceptAlert() | Accept current alert |
dismissAlert() | Dismiss current alert |
getAlertText() | Read current alert message |
enterAlertText() | Enter prompt value |
waitForAlert() | Synchronize with alert appearance |
Consider an employee management application. When the Delete button is clicked, a confirmation dialog appears.
Click Delete
↓
"Are you sure you want to delete?"
↓
┌───────────────┐
│ │
OK Cancel
│ │
↓ ↓
Delete Record Keep Record
Selenium implementation:
driver.findElement(By.id("delete")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(ExpectedConditions.alertIsPresent());
String message = alert.getText();
Assert.assertEquals(
message,
"Are you sure you want to delete?"
);
alert.accept();
Enter Username
↓
Enter Password
↓
Click Login
↓
Server Validation
↓
JavaScript Alert
↓
Read Error Message
↓
Accept Alert
↓
Verify Login Page
Click Enter Name
↓
Prompt Appears
↓
Switch to Alert
↓
Enter Name
↓
Click OK
↓
Application Displays Name
↓
Verify Result
| Method | Typical Meaning |
|---|---|
accept() | Confirm or click OK |
dismiss() | Cancel or close the dialog |
| Method | Purpose |
|---|---|
getText() | Reads alert text |
sendKeys() | Enters text into a prompt |
import java.time.Duration;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Assert;
public class JavaScriptAlertTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
driver.get("https://example.com");
driver.findElement(By.id("deleteButton")).click();
Alert alert =
wait.until(ExpectedConditions.alertIsPresent());
String actualMessage = alert.getText();
System.out.println("Alert Message: " + actualMessage);
Assert.assertEquals(
actualMessage,
"Are you sure you want to delete?"
);
alert.accept();
driver.quit();
}
}
| Exception | Possible Cause |
|---|---|
NoAlertPresentException | No alert is available when Selenium tries to access one |
TimeoutException | Expected alert did not appear within the wait timeout |
WebDriverException | General WebDriver-related failure |
The exception should be handled based on the test requirement. If the alert is mandatory, silently ignoring the exception can hide a real application or automation defect.
try {
Alert alert = driver.switchTo().alert();
alert.accept();
} catch (NoAlertPresentException e) {
Assert.fail("Expected JavaScript alert was not displayed.");
}
try {
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
alert.accept();
} catch (TimeoutException e) {
Assert.fail("Alert did not appear within expected time.");
}
When the alert message represents an important business requirement, validate it before accepting or dismissing the dialog.
Alert alert = driver.switchTo().alert();
String actualMessage = alert.getText();
Assert.assertEquals(
actualMessage,
"Payment completed successfully"
);
alert.accept();
Alert dialogs do not use standard Selenium locators such as ID, Name, XPath, or CSS Selector in the same way normal DOM elements do.
Incorrect:
driver.findElement(By.xpath("//div[@class='alert']")).click();For a native JavaScript alert, use:
driver.switchTo().alert().accept();An HTML modal is different from a JavaScript alert.
<div class="modal">
<h2>Delete Record</h2>
<p>Are you sure?</p>
<button id="confirmDelete">Yes</button>
<button id="cancelDelete">No</button>
</div>
This can normally be handled with WebElement methods:
driver.findElement(By.id("confirmDelete")).click();When testing a web application, determine whether the dialog is:
The correct Selenium technique depends on the type of dialog.
| Observed UI | Technique |
|---|---|
| Native JavaScript alert | switchTo().alert() |
| Native confirmation | alert.accept() / alert.dismiss() |
| Native prompt | alert.sendKeys() |
| HTML modal | WebElement locator |
| New tab/window | Window handles |
In a maintainable Selenium framework, the test should focus on business behavior while page objects and utility classes handle implementation details.
Test:
deleteEmployee()
verifyConfirmation()
confirmDeletion()
Page:
clickDelete()
AlertHelper:
waitForAlert()
getAlertText()
acceptAlert()
Alert alert = driver.switchTo().alert();
Assert.assertTrue(
alert.getText().contains("successfully")
);
alert.accept();
If the alert contains dynamic information, exact text matching may not always be appropriate.
String message = alert.getText();
Assert.assertTrue(
message.contains("successfully")
);
alert.accept();
Suppose an application displays:
Record 1254 deleted successfullyThe record number may change. A partial validation can be used when appropriate:
String message = alert.getText();
Assert.assertTrue(
message.contains("deleted successfully")
);
alert.accept();
Alert alert = driver.switchTo().alert();
String message = alert.getText();
System.out.println(
"JavaScript Alert Message: " + message
);
alert.accept();
System.out.println(
"JavaScript Alert Accepted"
);
JavaScript alert handling is particularly useful in regression suites because confirmation dialogs, validation alerts, and warning messages can appear across many workflows.
Alert messages and prompt values can also be tested using data-driven approaches.
String[] testInputs = {
"User1",
"User2",
"User3"
};
for (String input : testInputs) {
driver.findElement(By.id("promptButton")).click();
Alert alert = driver.switchTo().alert();
alert.sendKeys(input);
alert.accept();
System.out.println("Tested Input: " + input);
}
| Scenario | Expected Action |
|---|---|
| Information alert | Read and accept |
| Delete confirmation | Read and accept |
| Cancel deletion | Read and dismiss |
| Prompt input | Enter text and accept |
| Unexpected alert | Capture and report appropriately |
alertIsPresent() when timing is dynamic.Build a Selenium automation test for an employee management application.
Requirements:
driver.findElement(By.id("deleteEmployee")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
String message = alert.getText();
Assert.assertEquals(
message,
"Are you sure you want to delete?"
);
alert.accept();
Assert.assertTrue(
driver.findElement(By.id("deleteSuccess")).isDisplayed()
);
driver.findElement(By.id("deleteEmployee")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
alert.dismiss();
Assert.assertTrue(
driver.findElement(By.id("employeeRecord")).isDisplayed()
);
driver.findElement(By.id("enterName")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
Assert.assertEquals(
alert.getText(),
"Enter your name"
);
alert.sendKeys("Automation Tester");
alert.accept();
String result =
driver.findElement(By.id("displayName")).getText();
Assert.assertEquals(
result,
"Automation Tester"
);
A JavaScript alert is a browser dialog created by JavaScript that temporarily interrupts normal page interaction. Selenium handles it through the Alert interface rather than treating it as a normal WebElement.
Alert alert = driver.switchTo().alert();
alert.accept();
The Alert interface provides methods for accepting, dismissing, reading text, and entering prompt values.
String message = driver.switchTo().alert().getText();driver.switchTo().alert().accept();driver.switchTo().alert().dismiss();Alert alert = driver.switchTo().alert();
alert.sendKeys("Test Data");
alert.accept();
NoAlertPresentException can occur when Selenium attempts to access an alert that is not currently present.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
alert.accept();
A native JavaScript alert is not handled as a normal DOM element, so XPath is not the standard technique for interacting with it. Selenium's Alert interface should be used.
A JavaScript alert is a browser-managed dialog handled using driver.switchTo().alert(). An HTML popup or modal is part of the web page DOM and is normally handled using standard WebElement locators.
accept() is generally used for OK or confirmation, while dismiss() is generally used for Cancel or rejection.
Selenium Java provides the Alert interface for interacting with JavaScript dialogs.
No. sendKeys() is intended for prompt dialogs that accept text input. A simple alert normally does not provide an input field.
An alert may not appear immediately after the triggering action. ExpectedConditions.alertIsPresent() allows Selenium to wait for the alert instead of relying on an arbitrary fixed delay.
After the alert is accepted, the browser closes the dialog and Selenium can generally continue interacting with the page.
Create separate test scenarios. In one scenario call accept() and verify the confirmation behavior. In another scenario call dismiss() and verify that the operation is cancelled.
| Requirement | Code |
|---|---|
| Switch to alert | driver.switchTo().alert() |
| Accept | alert.accept() |
| Dismiss | alert.dismiss() |
| Read message | alert.getText() |
| Enter prompt value | alert.sendKeys("value") |
| Wait for alert | ExpectedConditions.alertIsPresent() |
| No alert exception | NoAlertPresentException |
// Switch
Alert alert = driver.switchTo().alert();
// Read
String text = alert.getText();
// Accept
alert.accept();
// Dismiss
alert.dismiss();
// Enter prompt text
alert.sendKeys("Test Data");
// Wait for alert
Alert alert = new WebDriverWait(driver, Duration.ofSeconds(10))
.until(ExpectedConditions.alertIsPresent());
alert().confirm().prompt().Alert interface.accept().dismiss().getText().sendKeys().findElement() for a native JavaScript alert.sendKeys() on a simple alert expecting an input field.dismiss() when the test requires confirmation.Thread.sleep().JavaScript Alerts are an important Selenium WebDriver concept used for automating browser dialogs generated by JavaScript. Selenium provides the Alert interface to interact with these dialogs. The primary operations are switching to the alert, reading its message, accepting it, dismissing it, and entering text into a prompt.
The most important commands are driver.switchTo().alert(), accept(), dismiss(), getText(), and sendKeys(). For dynamically appearing alerts, WebDriverWait with ExpectedConditions.alertIsPresent() provides a more reliable synchronization approach.
Always distinguish native JavaScript alerts from HTML/CSS modals, browser windows, and tabs because each requires a different Selenium handling technique. Proper alert handling makes Selenium automation more stable, maintainable, and suitable for real-world testing scenarios.
For structured Selenium automation learning, practical projects, Java-based Selenium training, and advanced browser interaction concepts, explore the JustAcademy Selenium Training Course.
To request a course demo, visit the JustAcademy Selenium Course Demo Registration.
